\chapter{Análisis}

	% á
	% é
	% í
	% ó
	% ú
	% ñ


\section{Introducción}

En esta etapa se realiza una descripción más detallada del problema en cuestión y se plantea una posible solución al mismo a través de una serie de pasos.\\
 A su vez, se incorpora el concepto de matriz de probabilidad con el fin de brindar al lector información referente a la solución antes mencionada.\\
 Para finalizar, se listan las dependencias externas involucradas en este trabajo acompañada con una breve descripción de cada una.


\section{Análisis del problema} \label{sec:analisis}

En esta sección se expone la descripción del problema además de una serie de pasos que componen la solución propuesta. Para una mayor comprensión de los cambios a realizar, en cada uno de los pasos se describe la nueva funcionalidad utilizando un lenguaje formal, acompañada de un prototipo de la función a implementar. Para finalizar, se muestra a modo de ejemplo, como se comporta la solución al trabajar con datos reales a partir de un caso de estudio determinado.

	
\subsection{Descripción del problema}
 Actualmente el único tratamiento posible para diezmar el avance del VIH es la aplicación de ARVs que tiene como finalidad interferir en algunos de los procesos que el virus realiza. Lamentablemente estas terapias no son efectivas a largo plazo, ya que dada la aplicación de un fármaco, éste deja de ser efectivo al cabo	de unos meses debido a que el virus muta para poder evitar la acción del mismo. 
 
 Para lograr un efecto más prolongado sobre el virus, se decidió cambiar la forma en la que se ``ataca'' al virus y utilizar un cocktail de ARVs en lugar de un único ARVs. Esta combinación de dos o más fármacos resulta mucha más potente que cada ARV por separado y provoca que el virus tenga que realizar un mayor esfuerzo para volverse resistente al mismo.
 
 Esta nueva forma de trabajo, implica realizar diferentes cambios de lo desarrollado hasta el momento.\\
		 
\subsection{Solución Propuesta} \label{sec:SolucionPropuesta}

\subsubsection{Entrada y Salida}
 La serie de pasos que intenta dar solución al problema, comienza a trabajar a partir de una secuencia nucleotídica y de una selección de ARVs que aplican sobre la misma. Esta secuencia se expresa en formato FASTA\footnote{Para mas información, visite \url{http://www.ncbi.nlm.nih.gov/blast/fasta.shtml}}, es decir, se representa una secuencia a través de una o mas líneas que contienen a lo sumo 80 caracteres. Además, pueden contener espacios en blanco y caracteres de alineación. La selección de ARVs es un subconjunto de los almacenados en la base de datos que \fudepan posee.
 
 Lo que se obtiene al final, es una lista ordenada de secuencias nucleotídicas denominadas mutantes, que son el resultado de aplicar la combinación de ARVs corriente sobre la secuencia de entrada.
 
 Formalmente, la entrada del pseudo-algoritmo se representa de la siguiente manera:    
\begin{itemize}
\item $PseudoNucSequence = ((A|U|C|G|P).(A|U|C|G|P).(A|U|C|G|P))^{+}$.\\ 
\\donde A, U, C, G representan nucleótidos y P representa un pseudo-nucleótido\footnote{Un pseudo-nucleótido puede codificar a A, U, C o G.}.   
\item $ARVs_{selected} = (ARV_{i})^{+}$\\
\\donde $ARV_{i}$ representa un ARV particular de la base de datos.
\end{itemize}

\begin{flushleft}
mientras que la salida:
\end{flushleft}
 
\begin{itemize}
\item $new\_sequences = (mutant_{i},$\hspace{0.1cm}$score_{i})^{+}$\\
\\ \hspace{0.15cm}donde,  $mutant_{i}$ representa el resultado de aplicar una combinación de codones sobre $PseudoNucSequence$ y $score_{i}$ la distancia genética entre entre $mutant_{i}$ y $PseudoNucSequence$\\
\end{itemize}
 
\subsubsection{Pseudo-algoritmo para la obtención de mutantes resistentes a un conjunto de ARVs} \label{pseudoalgoritmo}
 Para alcanzar el objetivo propuesto, la idea principal puede ser resumida en el siguiente pseudo-algoritmo:
\begin{itemize}	
	
\item[1)]\textbf{Pre-procesamiento de la Base de Datos de ARVs:} Teniendo en cuenta la secuencia nucleotídica que se corresponde con el virus del paciente, se reduce la información del conjunto de entrada de  ARVs eliminando todas aquellas resistencias cuyos                          aminoácidos estén presentes en la secuencia en las	correspondientes posiciones. Además, se actualiza el valor correspondiente al peso mínimo del grupo con la diferencia entre, el valor que tenía hasta el momento y el valor del peso de cada resistencia que se elimina.\\
 Formalmente:
\begin{itemize}
	\item[1.1)] \textit{Actualización del mínimo del grupo:} 	\\
	Considerando a $match(PseudoNucSeq, resistance) \rightarrow bool$, como la función que, dada una secuencia nucleotídica (\textit{seq}) y una resistencia (\textit{r}) perteneciente a un grupo (\textit{G}) determinado de un ARV, permite evaluar la coincidencia de los aminoácidos que 	contiene \textit{r} en \textit{seq};    
		\begin{center}
		Si $match(seq, r) \Longrightarrow (G_{w}\prime = G_{w}$ - $r_{w})$
		\end{center}
		donde, $G_{w}\prime$ es el resultante, $G_{w}$ representa el peso mínimo del grupo \textit{G}, $r_{w}$ el peso de la resistencia $r$, con $r \in G_{r}$ y $G_{r}$	el conjunto de resistencias de \textit{G}. Cabe destacar que el operador '-' representa la diferencia entre números.\\		
	\item[1.2)] \textit{Eliminación de las resistencias coincidentes con la secuencia:} \\
	Considerando a $match(PseudoNucSeq, resistance) \rightarrow bool$, $G_{r}$ y \textit{r} con las mismas definiciones anteriores;
		\begin{center}
		Si $match(seq, r) \Longrightarrow (G_{r}\prime$ $= G_{r} - \lbrace r \rbrace)$ \\
		\end{center}
		donde, $G_{r}\prime$ representa el resultado y el operador '$-$' la diferencia entre conjuntos.\\
	\end{itemize}

\textbf{Prototipo de la función}
\begin{lstlisting}[language=C++, basicstyle=\footnotesize\ttfamily, keywordstyle=\color{blue}, morekeywords={each, in, out}]		
void pre_processing(in: ARVs, sequence; out: ARVs_modified)
{
  apply_rule_1.1(sequence, ARVs);
  apply_rule_1.2(sequence, ARVs);
  ARVs_modified = ARVs;
}
\end{lstlisting}
\normalsize	
			
\item[2)]\textbf{Cálculo del conjunto de partes de los grupos de cada ARV:} Se calcula el conjunto de partes de cada grupo que pertenece a cada ARV:\\
\\Considerando a $ARVs_{modified}$ como el resultado de la aplicación del pre-procesamiento, se calcula el conjunto de partes para cada grupo $G_{i}$ perteneciente a cada ARV. Se define a R como el resultado de la unión de los conjuntos de partes resultantes, excluyendo al conjunto vacío, es decir:
\begin{center}
\[ R = \forall A_{i} \in ARVs_{m}(\bigcup_{G_{i} \in A_{i}} P(G_{i}) - \emptyset) \]
\end{center}
donde $A_{i}$ es un antiviral del conjunto de ARVs que se busca combinar y $ARVs_{m}$ representa a los antivirales modificados por el pre-procesamiento.\\

\pagebreak

\textbf{Prototipo de la función}
\small
\begin{lstlisting}[language=C++, basicstyle=\footnotesize\ttfamily, keywordstyle=\color{blue}, morekeywords={each, in, out}]		
void generate_power_set(in: ARVs_modified; out: R)
{
  for each (arv in ARVs_modified)
  {
    for each (group in arv)
    {
      R += P(group) - empty;
    }	
  }
}  
\end{lstlisting}
\normalsize

\item[3)]\textbf{Minimización del conjunto de partes:} Se aplican las siguientes reglas al conjunto \textit{R} obtenido anteriormente con el objetivo de eliminar información redundante e innecesaria. Sea: \\
- $R = \lbrace x_{1}, x_{2}, ... , x_{n} \rbrace$\\
- $x_{i}$ un elemento de \textit{R}, representado como: $\lbrace r_{1}, r_{2}, ... , r_{n}\rbrace$.\\ 
- $r_{i}$ que representa a una resistencia.\\
- El operador '$-$' que representa la diferencia de conjuntos.\\

Se calcula un nuevo conjunto, $R_{m}$, a partir de la eliminación de elementos de \textit{R} que resultan de la aplicación de las siguientes reglas.
Siendo $R_{m} = R$;
\begin{itemize}
  \item[3.1] \textit{Eliminación de elementos que no superen o igualen el peso mínimo del grupo:}	  
  Se eliminan aquellos $x_{i}$ cuyos pesos no superen o igualen al peso mínimo ($G_{w}$) del grupo al que pertenecen.\\
  Formalmente:	    
  \begin{center}
    Si $(weight(x_{i}) < G_{w}) \Longrightarrow (R_{m}\prime = R_{m} - x_{i})$,	  
  \end{center}		
  donde, $R_{m}\prime$ es el resultado, $weight(resistances) \rightarrow double$ representa la función que, dado un conjunto de resistencias, retorna la sumatoria de los pesos de cada una de ellas.\\
	  
  \item[3.2] \textit{Eliminación de elementos que estén incluidos en otros:} 
  Se eliminan aquellos $x_{j}$ de $R_{m}$ que contengan los elementos de algún $x_{i}$ que cumplan la condición del peso mínimo del grupo.\\
  Formalmente:
  \begin{center}
    Si $(x_{i} \subset x_{j}) \Longrightarrow (R_{m}\prime = R_{m} - x_{j})$ \footnote{$x_{i}$ y $x_{j}$ cumplen la condición del peso 			mínimo del grupo.}\\
  \end{center}		
  donde, $i \neq j$ y $R_{m}\prime$ representa el resultado.
\end{itemize}
	
\pagebreak	
	
\textbf{Prototipo de la función}
\small
\begin{lstlisting}[language=C++, basicstyle=\footnotesize\ttfamily, keywordstyle=\color{blue}, morekeywords={each, in, out}]	
void power_set_minimized(in: R; out: Rm)
{
  for each (elem in R)
  {
    apply_rule_3.1(elem);	
    apply_rule_3.2(elem);
  }
  Rm = R;
}  
\end{lstlisting}	
\normalsize
	
			
\item[4)]\textbf{Cálculo del producto cartesiano entre grupos de ARVs}: Sea $R_{m}$ el conjunto resultado obtenido en el paso anterior (minimización del conjunto R), se reagrupan todos los subconjuntos del mismo (cada uno de ellos representa algún elemento del conjunto de partes perteneciente a un grupo de un ARV determinado) de acuerdo al ARV al que pertenecen. Esto es:\\
- $R_{m}\_reagrupado = \lbrace G_{A1}, G_{A2}, ... , G_{An}\rbrace$;\\
- $G_{Ai} = \lbrace x_{1}, x_{2}, ..., x_{n}\rbrace$\footnote{Cabe aclarar que no es necesario discriminar estos elementos de acuerdo al grupo del cual provienen.}, donde cada $x_{j}$ pertenece al conjunto de partes de un grupo determinado del ARV '\textit{Ai}'.\\

A partir del nuevo conjunto, $R_{m}\_reagrupado$, se realiza el producto cartesiano entre cada uno de los $G_{Ai}$, es decir:

\begin{center}
$R_{x} = G_{A1}$ x $G_{A2}$ x $...$ x $G_{An}$
\end{center}

Cabe destacar que cada elemento $x_{i}$ perteneciente a $R_{x}$ tiene las resistencias necesarias para generar mutantes que sean resistentes a todos los ARVs de la selección corriente.\\


\textbf{Prototipo de la función}
\small
\begin{lstlisting}[language=C++, basicstyle=\footnotesize\ttfamily, keywordstyle=\color{blue}, morekeywords={each, in, out}]	
void generate_cartesian_product(in: Rm; out: Rx)
{
  for each (elem_i, elem_j in Rm)
  {
    cc_cartesian_product = elem_i x elem_j;
    Rx_aux.insert(cc_cartesian_product);
  }
  split_antivirals_x(Rx_aux, Rx);
}  

/** Funcion auxiliar necesaria */
void split_antivirals_x(in: combined; out: splited)
{
  for each (combination in combined)
  {
    if(combination.size() > 1)
    {
      for each (elem in combination)
      {      
        new_comb.insert(elem);
        splited.insert(new_comb);
      }
    }
    else
    {
      splited.insert(combination);
    }      
  }
}
\end{lstlisting}
\normalsize

Considerando a $insert(elem) \rightarrow void$, como la función de inserción de conjuntos.

La función \textit{void split\_antivirals\_x()} es necesaria para la expansión a nucleótidos debido a que transforma cada combinación compuesta ($\lbrace\lbrace r_{1}, r_{2} \rbrace; \lbrace r_{3} \rbrace \rbrace$) a una combinación simple ($\lbrace \lbrace r_{1} \rbrace; \lbrace r_{2} \rbrace; \lbrace r_{3} \rbrace \rbrace$).

\item[5)]\textbf{Expansión a codones:} Considerando a \textit{p} como un elemento de $R_{X}$, \textit{g} y \textit{x} como en el paso anterior, cada $r_{i}$ (resistencia) perteneciente a \textit{x} se representa de la siguiente manera:

$r_{i} = (pos_{i}, amin_{i}, weight_{i})$, donde $amin_{i}$ puede ser codificado por más de un codón.\\

Para cada resistencia $r_{i}$ perteneciente a $R_{X}$ se realiza el reemplazo de $amin_{i}$ por cada una de las posibles codificaciones a codones. En otras palabras, se realiza un nuevo producto cartesiano que corresponde a la expansión antes mencionada.\\  
Formalmente:\\

\small
$expand(r_{i}) \Longrightarrow (r_{i} = \lbrace (pos_{i}, codon_{i1}, weight_{i}), (pos_{i}, codon_{i2}, weight_{i}), (pos_{i}, codon_{i3}, weight_{i}) \rbrace )$\footnote{Considerando a $codon_{i1}, codon_{i2}, codon_{i3}$ como todas las posibles codificaciones de $amin_{i}$.}, \\


\normalsize
	donde $expand(resistance)\rightarrow list<resistance>$ representa la función que expande cada aminoácido de la resistencia tomada como entrada, a todas sus posibles codificaciones en codones.
	
	
\textbf{Prototipo de la función}
\begin{lstlisting}[language=C++, basicstyle=\footnotesize\ttfamily, keywordstyle=\color{blue}, morekeywords={each, in, out}]		
void expand_to_nucleotids(in: Rx; out: Rx_expanded)
{
  for each (elem in Rx)
  {
    for each (resistance in elem)
    {
      cc_resistance = expand_resistance(resistance);
      Rx_expanded.insert(cc_resistance);
    }
  }
}  
\end{lstlisting}	

Considerando a $insert(elem) \rightarrow void$, como la función de inserción de conjuntos.

\pagebreak

\item[6)]\textbf{Cálculo de distancias genéticas:} Para cada combinación en \textit{Rx\_expanded}, ahora representada en codones, se calcula su distancia mínima teniendo en cuenta la secuencia inicial y la matriz de distancias genéticas.

 Siendo $c_{1}=(n_{1},n_{2},n_{3})$ y $c_{2}=(n_{4},n_{5},n_{6})$ dos codones, $n_{i}$ un nucleótido, la distancia entre ambos codones se calcula sumando las distancias componente a componente. Formalmente:

\begin{flushleft}
$distance(c_{1}, c_{2}) = nucDist(n_{1}, n_{4}) + nucDist(n_{2}, n_{5}) + nucDist(n_{3}, n_{6})$
\end{flushleft}

donde, $nucDist(nuc1, nuc2) \rightarrow double$ es una función que retorna la distancia entre dos nucleótidos, basándose en la información almacenada en la matriz de distancias genéticas \footnote{En el caso de un pseudo-nucleótido, el cual puede codificar a A, C, T o G, se toma la menor distancia de todas sus posibles codificaciones.}.

Luego de aplicar esta función a todo el conjunto \textit{Rx\_expanded}, se obtiene como resultado un nuevo conjunto, \textit{Rx\_with\_distances}, el cual contendrá cada combinación con su respectiva distancia genética.\\

\textbf{Prototipo de la función}
\begin{lstlisting}[language=C++, basicstyle=\footnotesize\ttfamily, keywordstyle=\color{blue}, morekeywords={each, in, out}]	
void calculate_genetic_distance(in: Rx_expanded; out: Rx_with_distances)
{
  for each (comb in Rx_expanded)
  {
    cc_comb = get_comb_distance(sequence, comb);
    Rx_with_distances.insert(cc_comb);
  }
}  
\end{lstlisting}	

Considerando a $insert(elem) \rightarrow void$, como la función de inserción de conjuntos.

\item[7)]\textbf{Armado de ranking de ARVs:} Se arma un ranking con aquellas combinaciones que se encuentran en \textit{Rx\_with\_distances}, cuyas distancias genéticas se encuentren dentro del rango determinado a partir de un porcentaje de tolerancia definido previamente.\\
Las combinaciones seleccionadas, son aquellas por las que el virus obtará con mayor probabilidad para su mutación.\\

\textbf{Prototipo de la función}
\begin{lstlisting}[language=C++, basicstyle=\footnotesize\ttfamily, keywordstyle=\color{blue}, morekeywords={each, in, out}]		
void rank_combinations(in: Rx_with_distances; out: Ranking)
{
  for each (comb in Rx_with_distances)
  {
    if (is_in_range(comb))
    {
      Ranking.add(comb);
    }	
  }
}  
\end{lstlisting}

Considerando a \textit{is\_in\_range(combination)}$\rightarrow bool$ como la función que analiza si la distancia de la combinación que recibe como parámetro, se encuentra dentro del rango determinado a partir del porcentaje de tolerancia antes definido y $add(elem) \rightarrow void$ la operación de inserción sobre listas.

\item[8)]\textbf{Generación de secuencias mutantes:} Se generan las secuencias mutantes a partir de aplicar cada combinación del ranking sobre la secuencia inicial. Es decir:
\begin{center}
$\forall r \in Ranking: r \rightarrow Seq \Longrightarrow mutant_{r}$\\
\end{center}

 Es decir, el número de combinaciones contenidas en el ranking será igual al número de secuencias mutantes generadas.
 
\textbf{Prototipo de la función}
\begin{lstlisting}[language=C++, basicstyle=\footnotesize\ttfamily, keywordstyle=\color{blue}, morekeywords={each, in, out}]	
void generate_mutants(in: Ranking; out: Mutants)
{
  for each (r in Ranking)
  {
    cc_mutant = r.replace_in(sequence);
    Mutants.add(cc_mutant);
  }
}  
\end{lstlisting}

Considerando a $add(elem) \rightarrow void$ como la operación de inserción sobre listas.
 
\end{itemize}


\subsubsection{Ejemplo}		

\begin{itemize}

\item[\textbf{1)}]
- Dada la secuencia nucleotídica:
\begin{center}
\textit{\textcolor{red}{CCT}CAG\textcolor{red}{AGA}ACT\textcolor{red}{CTT}TGG\textcolor{red}{CAA}CGA\textcolor{red}{CCC}CTC\textcolor{red}{GTC}ACA\textcolor{red}{ATA}AAG...}
\end{center}

- El fragmento de la base de datos de ARVs:

\begin{lstlisting}[language=XML, keywordstyle=\color{blue}, morekeywords={xmlns,version,type,id,class}]
<antivirals>
...
<antiviral id="NRTI3" num = "3" type = "tRT" class = "cNRTI">
  <group min="0.5">
    <resistance pos="4" aminos="V" weight="1.0"/>
  </group>
  <group min="2.5">
    <resistance pos="6" aminos="T" weight="1.0"/>
    <resistance pos="8" aminos="R" weight="0.8"/>
    <resistance pos="10" aminos="V" weight="1.9"/>
  </group>
</antiviral>

<antiviral id="NRTI1" num = "1" type = "tRT" class = "cNRTI"> 
  <group min="3.0">
    <resistance pos="1" aminos="I" weight="1.0"/>
    <resistance pos="4" aminos="T" weight="1.0"/>   <!--matched-->		
    <resistance pos="5" aminos="R" weight="1.0"/>
  </group>
  <group min="1.5">
    <resistance pos="7" aminos="R" weight="0.5"/>
    <resistance pos="9" aminos="T" weight="1.0"/>
    <resistance pos="12" aminos="I" weight="1.0"/>
  </group>
</antiviral>
...
</antivirals>

\end{lstlisting}				

Se analizan todas las posiciones de resistencias para determinar coincidencias con res\-pecto a la secuencia. 

 La primer coincidencia aparece en la resistencia que contiene al aminoácido R(Arginina), ya que de acuerdo a la tabla del Código Genético, Figura \ref{fig:CodigoGenetico}, los codones \textit{CGT, CGC, CGA, CGG, AGG} y \textit{\textbf{AGA}} codifican a dicho aminoácido. El codón AGA ocupa la tercera posición de la secuencia.\\
Luego de aplicar las fórmulas, 1.1 y 1.2, se obtiene:

\begin{lstlisting}[language=XML, keywordstyle=\color{blue}, morekeywords={xmlns,version,type,id,class}]	
...
  <group min="1.7">
    <resistance pos="6" aminos="T" weight="1.0"/>
    <resistance pos="10" aminos="V" weight="1.9"/>
  </group>
...
\end{lstlisting}	

 Lo mismo ocurre (segunda coincidencia - novena posición) con la resistencia que contiene al aminoácido T(Treonina), el cual es codificado por los codones \textit{ACG, ACC, ACA} y \textit{\textbf{ACU}}.

\begin{lstlisting}[language=XML, keywordstyle=\color{blue}, morekeywords={xmlns,version,type,id,class}]
...
  <group min="2.0">
    <resistance pos="1" aminos="I" weight="1.0"/>	
    <resistance pos="5" aminos="R" weight="1.0"/>
  </group>
...
\end{lstlisting}	 

Como resultado final, obtenemos la siguiente base de datos de ARVs:

\begin{lstlisting}[language=XML, keywordstyle=\color{blue}, morekeywords={xmlns,version,type,id,class}]
<antivirals>
...
<antiviral id="NRTI3" num = "3" type = "tRT" class = "cNRTI">
  <group min="0.5">
    <resistance pos="4" aminos="V" weight="1.0"/>
  </group>
  <group min="1.7">
    <resistance pos="6" aminos="T" weight="1.0"/>
    <resistance pos="10" aminos="V" weight="1.9"/>
  </group>
</antiviral>

<antiviral id="NRTI1" num = "1" type = "tRT" class = "cNRTI"> 
  <group min="2.0">
    <resistance pos="1" aminos="I" weight="1.0"/>			
    <resistance pos="5" aminos="R" weight="1.0"/>
  </group>
  <group min="1.5">
    <resistance pos="7" aminos="R" weight="0.5"/>
    <resistance pos="9" aminos="T" weight="1.0"/>	
    <resistance pos="12" aminos="I" weight="1.0"/>
  </group>
</antiviral>
...
</antivirals>
\end{lstlisting}						

\item[\textbf{2)}] Se genera el conjunto \textit{R}, el cual queda conformado de la siguiente manera:

\begin{lstlisting}[language=XML, keywordstyle=\color{blue}, morekeywords={xmlns,version,type,id,class}]	
<!--NRTI3-->
<group min="0.5">
  <!-- Combinacion 1 -->
  <resistance pos="4" aminos="V" weight="1.0"/>

<group min="1.7">
  <!-- Combinacion 2 -->
  <resistance pos="6" aminos="T" weight="1.0"/>
  
  <!-- Combinacion 3 -->
  <resistance pos="10" aminos="V" weight="1.9"/>

  <!-- Combinacion 4 -->
  <resistance pos="6" aminos="T" weight="1.0"/>
  <resistance pos="10" aminos="V" weight="1.9"/>

<!--NRTI1-->
<group min="2.0">
  <!-- Combinacion 1 -->
  <resistance pos="1" aminos="I" weight="1.0"/>	

  <!-- Combinacion 2 -->
  <resistance pos="5" aminos="R" weight="1.0"/>

  <!-- Combinacion 3 -->
  <resistance pos="1" aminos="I" weight="1.0"/>	
  <resistance pos="5" aminos="R" weight="1.0"/>

<group min="1.5">
  <!-- Combinacion 4 -->
  <resistance pos="7" aminos="R" weight="0.5"/>  
  
  <!-- Combinacion 5 -->
  <resistance pos="9" aminos="T" weight="1.0"/>		  

  <!-- Combinacion 6 -->
  <resistance pos="12" aminos="I" weight="1.0"/>
  
  <!-- Combinacion 7 -->
  <resistance pos="7" aminos="R" weight="0.5"/>
  <resistance pos="9" aminos="T" weight="1.0"/>		

  <!-- Combinacion 8 -->
  <resistance pos="7" aminos="R" weight="0.5"/>
  <resistance pos="12" aminos="I" weight="1.0"/>

  <!-- Combinacion 9 -->
  <resistance pos="9" aminos="T" weight="1.0"/>		
  <resistance pos="12" aminos="I" weight="1.0"/>
  
  <!-- Combinacion 10 -->
  <resistance pos="7" aminos="R" weight="0.5"/>
  <resistance pos="9" aminos="T" weight="1.0"/>
  <resistance pos="12" aminos="I" weight="1.0"/>
\end{lstlisting}				

\item[\textbf{3)}] Cabe destacar que para mejorar la legibilidad se opta por una nueva notación para re\-pre\-sen\-tar las resistencias; ahora van a ser 3-uplas que contienen (posición, aminoácidos, peso). 
 Aplicando las reglas de minimización sobre el conjunto \textit{R},  se obtiene el siguiente conjunto $R_{m}$:

\begin{lstlisting}[language=XML]
<!--NRTI3-->
<group min="0.5">   
    <!-- Combinacion 1 -->
    <!--(4, V, 1.0)-->

<group min="1.7">
    <!-- Combinacion 2 -->
    <!-- Se elimina por regla 3.1 -->

    <!-- Combinacion 3 -->
    <!--(10, V, 1.9)-->
    
    <!-- Combinacion 4 -->
    <!-- Se elimina por regla 3.2 -->

<!--NRTI1-->
<group min="2.0">
	<!-- Combinacion 1 -->
    <!-- Se elimina por regla 3.1 -->

    <!-- Combinacion 2 -->
    <!-- Se elimina por regla 3.1 -->
    
    <!-- Combinacion 3 -->
    <!--(1, I, 1.0)-->		
    <!--(5, R, 1.0)-->

<group min="1.5">
	<!-- Combinacion 4 -->
    <!-- Se elimina por regla 3.1 -->

    <!-- Combinacion 5 -->
    <!-- Se elimina por regla 3.1 -->
    
    <!-- Combinacion 6 -->
    <!-- Se elimina por regla 3.1 -->

    <!-- Combinacion 7 -->
    <!--(7, R, 0.5)-->
    <!--(9, T, 1.0)-->			

    <!-- Combinacion 8 -->
    <!--(7, R, 0.5)-->
    <!--(12, I, 1.0)-->

    <!-- Combinacion 9 -->
    <!--(9, T, 1.0)-->		
    <!--(12, I, 1.0)-->	
    
    <!-- Combinacion 10 -->	
    <!-- Se elimina por regla 3.2 -->
\end{lstlisting}		

En representación formal:

\begin{flushleft}
$R_{m}$ = $\lbrace\lbrace\left[(4; V; 1.0)\right], \left[(10; V; 1.9)\right]\rbrace, 
			\lbrace\left[(1; I; 1.0),(5; R; 1.0)\right],\left[(7, R, 0.5),(9, T, 1.0)\right],$\\ \hspace{1,5cm}$\left[(7, R, 0.5),(12, I, 1.0)\right], \left[(9, T, 1.0),(12, I, 1.0)\right]\rbrace\rbrace$\\
\end{flushleft}

\item[\textbf{4)}] El producto cartesiano entre los elementos de $R_{m}$, se almacena en un nuevo conjunto denominado $R_{X}$:

\begin{flushleft}
$R_{X} = \lbrace\lbrace(4; V; 1.0),(1; I; 1.0),(5; R; 1.0)\rbrace, \lbrace(4; V; 1.0),(7, R, 0.5),(9, T, 1.0)\rbrace,$\\
			\hspace{1,1cm} $\lbrace(4; V; 1.0),(7, R, 0.5),(12, I, 1.0)\rbrace, \lbrace(4; V; 1.0),(9, T, 1.0),(12, I, 1.0)\rbrace,$\\
			\hspace{1,1cm} $\lbrace(10; V; 1.9),(1; I; 1.0),(5; R; 1.0)\rbrace, \lbrace(10; V; 1.9),(7, R, 0.5),(9, T, 1.0)\rbrace,$\\
			\hspace{1,1cm} $\lbrace(10; V; 1.9),(7, R, 0.5),(12, I, 1.0)\rbrace, \lbrace(10; V; 1.9),(9, T, 1.0),(12, I, 1.0)\rbrace\rbrace$
\end{flushleft}


\item[\textbf{5)}] Teniendo en cuenta la Figura \ref{fig:CodigoGenetico}, los aminoácidos involucrados expanden a los siguientes codones:

\begin{flushleft}
- V (Valina): GTT, GTC, GTA, GTG;\\
- T (Treonina): ACT, ACC, ACA, ACG;\\
- I (Isoleucina): ATT, ATC, ATA;\\
- R (Arginina): CGT, CGC, CGA, CGG, AGA, AGG;\\
\end{flushleft}

Debido a que el conjunto $R_{X}$ contiene un gran número de combinaciones de aminoácidos, se toma el primer elemento para expandir, con el fin de hacer notar el potencial crecimiento del número de elementos resultantes.

\begin{flushleft}

$R_{X} = $ \small $\lbrace\lbrace(10; V; 1.9),(9, T, 1.0),(12, I, 1.0)\rbrace, ... \rbrace$
\end{flushleft}

%(10, GUU)(10, GUC)(10, GUA)(10, GUG); (9, ACU)(9, ACC)(9, ACA)(9, ACG); (12, AUU)(12, AUC)(12, AUA)
\normalsize

Se expande a:\\

$R_{X} = $\\
\small
$\lbrace\lbrace(10;GTT;1.9),(9;ACT;1.0),(12;ATT;1.0)\rbrace, \lbrace(10;GTT;1.9),(9;ACT;1.0),(12;ATC;1.0)\rbrace, $\\
\hspace{1cm}$\lbrace(10;GTT;1.9),(9;ACT;1.0),(12;ATA;1.0)\rbrace, \lbrace(10;GTT;1.9),(9;ACC;1.0),(12;ATT;1.0)\rbrace, $\\
\hspace{1cm}$\lbrace(10;GTT;1.9),(9;ACC;1.0),(12;ATC;1.0)\rbrace, \lbrace(10;GTT;1.9),(9;ACC;1.0),(12;ATA;1.0)\rbrace, $\\ 
\hspace{1cm}$\lbrace(10;GTT;1.9),(9;ACA;1.0),(12;ATT;1.0)\rbrace \lbrace(10;GTT;1.9),(9;ACA;1.0),(12;ATC;1.0)\rbrace, $\\
\hspace{1cm}$\lbrace(10;GTT;1.9),(9;ACA;1.0),(12;ATA;1.0)\rbrace, \lbrace(10;GTT;1.9),(9;ACG;1.0),(12;ATT;1.0)\rbrace, $\\
\hspace{1cm}$\lbrace(10;GTT;1.9),(9;ACG;1.0),(12;ATC;1.0)\rbrace, \lbrace(10;GTT;1.9),(9;ACG;1.0),(12;ATA;1.0)\rbrace, $\\ 	
\hspace{1cm}$\lbrace(10;GTC;1.9),(9;ACT;1.0),(12;ATT;1.0)\rbrace, \lbrace(10;GTC;1.9),(9;ACT;1.0),(12;ATC;1.0)\rbrace, $\\
\hspace{1cm}$\lbrace(10;GTC;1.9),(9;ACT;1.0),(12;ATA;1.0)\rbrace, \lbrace(10;GTC;1.9),(9;ACC;1.0),(12;ATT;1.0)\rbrace, $\\
\hspace{1cm}$\lbrace(10;GTC;1.9),(9;ACC;1.0),(12;ATC;1.0)\rbrace, \lbrace(10;GTC;1.9),(9;ACC;1.0),(12;ATA;1.0)\rbrace, $\\ 
\hspace{1cm}$\lbrace(10;GTC;1.9),(9;ACA;1.0),(12;ATT;1.0)\rbrace \lbrace(10;GTC;1.9),(9;ACA;1.0),(12;ATC;1.0)\rbrace, $\\
\hspace{1cm}$\lbrace(10;GTC;1.9),(9;ACA;1.0),(12;ATA;1.0)\rbrace, \lbrace(10;GTC;1.9),(9;ACG;1.0),(12;ATT;1.0)\rbrace, $\\
\hspace{1cm}$\lbrace(10;GTC;1.9),(9;ACG;1.0),(12;ATC;1.0)\rbrace, \lbrace(10;GTC;1.9),(9;ACG;1.0),(12;ATA;1.0)\rbrace, $\\
\hspace{1cm}$\lbrace(10;GTA;1.9),(9;ACT;1.0),(12;ATT;1.0)\rbrace, \lbrace(10;GTA;1.9),(9;ACT;1.0),(12;ATC;1.0)\rbrace, $\\
\hspace{1cm}$\lbrace(10;GTA;1.9),(9;ACT;1.0),(12;ATA;1.0)\rbrace, \lbrace(10;GTA;1.9),(9;ACC;1.0),(12;ATT;1.0)\rbrace, $\\
\hspace{1cm}$\lbrace(10;GTA;1.9),(9;ACC;1.0),(12;ATC;1.0)\rbrace, \lbrace(10;GTA;1.9),(9;ACC;1.0),(12;ATA;1.0)\rbrace, $\\ 
\hspace{1cm}$\lbrace(10;GTA;1.9),(9;ACA;1.0),(12;ATT;1.0)\rbrace \lbrace(10;GTA;1.9),(9;ACA;1.0),(12;ATC;1.0)\rbrace, $\\
\hspace{1cm}$\lbrace(10;GTA;1.9),(9;ACA;1.0),(12;ATA;1.0)\rbrace, \lbrace(10;GTA;1.9),(9;ACG;1.0),(12;ATT;1.0)\rbrace, $\\
\hspace{1cm}$\lbrace(10;GTA;1.9),(9;ACG;1.0),(12;ATC;1.0)\rbrace, \lbrace(10;GTA;1.9),(9;ACG;1.0),(12;ATA;1.0)\rbrace, $\\
\hspace{1cm}$\lbrace(10;GTG;1.9),(9;ACT;1.0),(12;ATT;1.0)\rbrace, \lbrace(10;GTG;1.9),(9;ACT;1.0),(12;ATC;1.0)\rbrace, $\\
\hspace{1cm}$\lbrace(10;GTG;1.9),(9;ACT;1.0),(12;ATA;1.0)\rbrace, \lbrace(10;GTG;1.9),(9;ACC;1.0),(12;ATT;1.0)\rbrace, $\\
\hspace{1cm}$\lbrace(10;GTG;1.9),(9;ACC;1.0),(12;ATC;1.0)\rbrace, \lbrace(10;GTG;1.9),(9;ACC;1.0),(12;ATA;1.0)\rbrace, $\\ 
\hspace{1cm}$\lbrace(10;GTG;1.9),(9;ACA;1.0),(12;ATT;1.0)\rbrace \lbrace(10;GTG;1.9),(9;ACA;1.0),(12;ATC;1.0)\rbrace, $\\
\hspace{1cm}$\lbrace(10;GTG;1.9),(9;ACA;1.0),(12;ATA;1.0)\rbrace, \lbrace(10;GTG;1.9),(9;ACG;1.0),(12;ATT;1.0)\rbrace, $\\
\hspace{1cm}$\lbrace(10;GTG;1.9),(9;ACG;1.0),(12;ATC;1.0)\rbrace, \lbrace(10;GTG;1.9),(9;ACG;1.0),(12;ATA;1.0)\rbrace...\rbrace$\\

%\footnote{Es decir, se realiza un nuevo producto cartesiano a nivel de codones.}

\normalsize
Es decir, se realiza un nuevo producto cartesiano a nivel de codones.\\

\item[\textbf{6)}] A cada elemento del conjunto obtenido anteriormente, se le calcula su distancia genética.

\begin{flushleft}
\textit{Rx\_with\_distances} = \\

\small

\hspace{0,8cm}$\lbrace\left[\lbrace(10;GTT;1.9),(9;ACT;1.0),(12;ATT;1.0)\rbrace, 5\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTT;1.9),(9;ACT;1.0),(12;ATC;1.0)\rbrace, 5\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTT;1.9),(9;ACT;1.0),(12;ATA;1.0)\rbrace, 7\right]$\\ 
\hspace{1cm}$\left[\lbrace(10;GTT;1.9),(9;ACC;1.0),(12;ATT;1.0)\rbrace, 5\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTT;1.9),(9;ACC;1.0),(12;ATC;1.0)\rbrace, 4\right]$\\ 
\hspace{1cm}$\left[\lbrace(10;GTT;1.9),(9;ACC;1.0),(12;ATA;1.0)\rbrace, 4\right]$\\ 
\hspace{1cm}$\left[\lbrace(10;GTT;1.9),(9;ACA;1.0),(12;ATT;1.0)\rbrace, 3\right]$\\ 
\hspace{1cm}$\left[\lbrace(10;GTT;1.9),(9;ACA;1.0),(12;ATC;1.0)\rbrace, 9\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTT;1.9),(9;ACA;1.0),(12;ATA;1.0)\rbrace, 3\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTT;1.9),(9;ACG;1.0),(12;ATT;1.0)\rbrace, 7\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTT;1.9),(9;ACG;1.0),(12;ATC;1.0)\rbrace, 6\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTT;1.9),(9;ACG;1.0),(12;ATA;1.0)\rbrace, 5\right]$\\ 	
\hspace{1cm}$\left[\lbrace(10;GTC;1.9),(9;ACT;1.0),(12;ATT;1.0)\rbrace, 8\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTC;1.9),(9;ACT;1.0),(12;ATC;1.0)\rbrace, 7\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTC;1.9),(9;ACT;1.0),(12;ATA;1.0)\rbrace, 5\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTC;1.9),(9;ACC;1.0),(12;ATT;1.0)\rbrace, 4\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTC;1.9),(9;ACC;1.0),(12;ATC;1.0)\rbrace, 4\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTC;1.9),(9;ACC;1.0),(12;ATA;1.0)\rbrace, 3\right]$\\ 
\hspace{1cm}$\left[\lbrace(10;GTC;1.9),(9;ACA;1.0),(12;ATT;1.0)\rbrace, 7\right]$\\ 
\hspace{1cm}$\left[\lbrace(10;GTC;1.9),(9;ACA;1.0),(12;ATC;1.0)\rbrace, 4\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTC;1.9),(9;ACA;1.0),(12;ATA;1.0)\rbrace, 5\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTC;1.9),(9;ACG;1.0),(12;ATT;1.0)\rbrace, 5\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTC;1.9),(9;ACG;1.0),(12;ATC;1.0)\rbrace, 3\right]$\\ 
\hspace{1cm}$\left[\lbrace(10;GTC;1.9),(9;ACG;1.0),(12;ATA;1.0)\rbrace, 7\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTA;1.9),(9;ACT;1.0),(12;ATT;1.0)\rbrace, 8\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTA;1.9),(9;ACT;1.0),(12;ATC;1.0)\rbrace, 8\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTA;1.9),(9;ACT;1.0),(12;ATA;1.0)\rbrace, 6\right]$\\ 
\hspace{1cm}$\left[\lbrace(10;GTA;1.9),(9;ACC;1.0),(12;ATT;1.0)\rbrace, 9\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTA;1.9),(9;ACC;1.0),(12;ATC;1.0)\rbrace, 5\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTA;1.9),(9;ACC;1.0),(12;ATA;1.0)\rbrace, 3\right]$\\ 
\hspace{1cm}$\left[\lbrace(10;GTA;1.9),(9;ACA;1.0),(12;ATT;1.0)\rbrace, 7\right]$\\ 
\hspace{1cm}$\left[\lbrace(10;GTA;1.9),(9;ACA;1.0),(12;ATC;1.0)\rbrace, 8\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTA;1.9),(9;ACA;1.0),(12;ATA;1.0)\rbrace, 6\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTA;1.9),(9;ACG;1.0),(12;ATT;1.0)\rbrace, 7\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTA;1.9),(9;ACG;1.0),(12;ATC;1.0)\rbrace, 6\right]$\\
\hspace{1cm}$\left[\lbrace(10;GTA;1.9),(9;ACG;1.0),(12;ATA;1.0)\rbrace, 5\right]...\rbrace$\\
\end{flushleft}


\normalsize

\item[\textbf{7)}] Una vez calculada la distancia de cada combinación, se arma un ranking con aquellas combinaciones cuyas distancias estén dentro del rango definido a partir del porcentaje de tolerancia. Esto es,

\begin{flushleft}
\small
\textit{Ranking} = $\lbrace\left[\lbrace(10;GTT;1.9),(9;ACA;1.0),(12;ATT;1.0)\rbrace, 3\right]$\\
\hspace{2,15cm}$\left[\lbrace(10;GTC;1.9),(9;ACG;1.0),(12;ATT;1.0)\rbrace, 3\right]$\\
\hspace{2,15cm}$\left[\lbrace(10;GTC;1.9),(9;ACG;1.0),(12;ATC;1.0)\rbrace, 3\right]$\\ 
\hspace{2,15cm}$\left[\lbrace(10;GTC;1.9),(9;ACG;1.0),(12;ATA;1.0)\rbrace, 4\right]$\\
\hspace{2,15cm}$\left[\lbrace(10;GTA;1.9),(9;ACT;1.0),(12;ATT;1.0)\rbrace, 4\right]\rbrace$ 
\end{flushleft}

\normalsize

Tomando como límite inferior,  aquellas combinaciones con mínima distancia (distancia 3)  y como límite superior, aquellas cuya distancia sea igual a la distancia mínima mas el porcentaje de tolerancia (distancia 4, tomando una tolerancia de 1.0).
 
\item[\textbf{8)}] Para cada combinación contenida en el ranking, y partiendo de la secuencia inicial, se obtiene una nueva secuencia mutante. Se van a generar tantas secuencias mutantes como elementos contenga el ranking.

\begin{flushleft}
Secuencia Inicial:\\ 
\vspace{0.2cm}
\hspace{1cm} CCTCAGAGAACTCTTTGGCAACGACCCCTCGTCACAATAAAG...

Secuencia mutante 1: \\
\vspace{0.2cm}
	\hspace{1cm} CCTCAGAGAACTCTTTGGCAACGA\underline{\textbf{ACA}} \underline{\textbf{GTT}}GTC\underline{\textbf{ATT}}ATAAAG... \\
\vspace{0.2cm}
Secuencia mutante 2: \\
\vspace{0.2cm}
	\hspace{1cm} CCTCAGAGAACTCTTTGGCAACGA\underline{\textbf{ACG}} \underline{\textbf{GTC}}GTC\underline{\textbf{ATT}}ATAAAG... \\
\vspace{0.2cm}
Secuencia mutante 3: \\
\vspace{0.2cm}
	\hspace{1cm} CCTCAGAGAACTCTTTGGCAACGA\underline{\textbf{ACG}} \underline{\textbf{GTC}}GTC\underline{\textbf{ATC}}ATAAAG... \\
\vspace{0.2cm}
Secuencia mutante 4: \\	
\vspace{0.2cm}
	\hspace{1cm} CCTCAGAGAACTCTTTGGCAACGA\underline{\textbf{ACG}} \underline{\textbf{GTC}}GTC\underline{\textbf{ATA}}ATAAAG... \\
\vspace{0.2cm}
Secuencia mutante 5: \\	
\vspace{0.2cm}
	\hspace{1cm} CCTCAGAGAACTCTTTGGCAACGA\underline{\textbf{ACT}} \underline{\textbf{GTA}}GTC\underline{\textbf{ATT}}ATAAAG...		
\vspace{0.2cm}	
\end{flushleft}

Éstas secuencias obtenidas anteriormente, permiten simular los posibles ``caminos" por los que puede optar el virus VIH, para escapar a la acción del conjunto de ARVs aplicados.

\end{itemize}			

	
\subsection{Legacy code}
	%Intro
	La solución que se propone en la sección \ref{sec:SolucionPropuesta}, implica realizar cambios sobre un proyecto existente. El objetivo de esta sección es identificar aquellas partes del producto que deben ser modificadas y cuál es el resultado aportado por cada modificación.

\subsubsection{Estructura del producto a refactorizar}
	%Intro
	En la Figura \ref{fig:EstructuraARefactorizar} se destacan aquellas partes del sistema que van a sufrir modificaciones.

\begin{figure}[h!]
\centering
\def\blockdist{1.0}
	\small
  	\begin{tikzpicture}[auto,
    block_center/.style ={rectangle, draw=black, thick, fill=blue!30,
      text width=8em, text centered, minimum height=4em},
    block_center1/.style ={rectangle, draw=black, thick, fill=none,
      text width=12em, text centered, minimum height=1em},
    line/.style ={draw, thick, -latex', shorten >=0pt},
    line_dashed/.style ={draw, dashed, thick, -latex', shorten >=0pt}]
    
    \selectlanguage{english}

	% Cajas
    \matrix [column sep=13mm,row sep=10mm] {
	  % row 1
      	\node [block_center] (AVSet) {Antiviral\_Selector};
      & \node [block_center1] (applies) {applies()};\\
      % row 2
      	\node [block_center] (combinator1) {Combinator};
      & \node [block_center1] (combR) {combine\_resistances()};\\
 	  % row 3     
 	  	\node [block_center] (ranker1) {Ranker};
      & \node [block_center1] (rankC) {rank\_combinations()};\\
      % row 4
		\node [block_center] (mutants1) {Mutants};
      & \node [block_center1] (generateM) {generate\_mutants()};\\
      };% end matrix
   
   	% Flechas continuas
	\begin{scope}[every path/.style=line]
    	\path (AVSet) -- (combinator1);
		\path (combinator1) -- (ranker1);
      	\path (ranker1) -- (mutants1);
	\end{scope}     
        
	% Flechas discontinuas    
   	\begin{scope}[every path/.style=line_dashed]
		\path (applies) -- (AVSet);
     	\path (combR) -- (combinator1);
  		\path (rankC) -- (ranker1);
  		\path (generateM) -- (mutants1);
  	\end{scope}    
   
\end{tikzpicture}
\caption{\small Estructura a refactorizar}
\selectlanguage{spanish}
\label{fig:EstructuraARefactorizar}
\end{figure}


\normalsize	
\aproba requiere una refactorización de los diferentes métodos implementados hasta el momento. Dichos métodos son explicados a continuación, destacando la funcionalidad anterior, y la nueva funcionalidad.
%Teniendo en cuenta la estructura que existe actualmente y de acuerdo a la solucion planteada, se realiza una refactorización de los diferentes métodos implementados hasta el momento. Dichos métodos son:
		
\begin{itemize}

	\item \textsl{applies()}\\
		Este método forma parte del componente \textit{Antiviral\_Selector}, el cual es explicado en la sección \ref{sec:DescripFuncionamiento} del capitulo de Diseño.
	
	\begin{itemize}		
		\item \textit{Funcionalidad anterior: } Analiza la aplicabilidad de un ARV en base a sus resistencias.\\
			
\textbf{Pseudo-algoritmo}
\begin{lstlisting}[language=C++]	
int applies(in: sequence; in: arv)
{
  min_distance = 3;  // Maximo valor posible
  while(!empty(arv.resistances) && min_distance > 0)
  {
    cc_distance = calculate_distance(arv.resistances, sequence);
    min_distance = min(min_distance, cc_distance);
  }
  return min_distance;
}  
\end{lstlisting}

Considerando a $empty(l) \rightarrow bool$ como la función que controla si la lista \textit{'l'} contiene elementos o no; y a calculate\_distance(res, seq) $\rightarrow int$ como la función que calcula la distancia genética entre la resistencia \textit{'res'} y la secuencia \textit{'seq'}.\\
			

		\item \textit{Funcionalidad nueva: } Analiza la aplicabilidad de un antirretoviral en base a cada resistencia de cada grupo del mismo.\\ 		
			
\textbf{Pseudo-algoritmo}
\begin{lstlisting}[language=C++]	
int applies(in: sequence; in: arv)
{
  min_distance = 3;  // Maximo valor posible
  for each (group in arv)
  {
    while(!empty(group.resistances) && min_distance > 0)
    {
      cc_distance = calculate_distance(group.resistances, sequence);
      min_distance = min(min_distance, cc_distance);
    }
  }
  return min_distance;
} 
\end{lstlisting}

Considerando a $empty(l) \rightarrow bool$ y \textit{calculate\_distance(res, seq)} $\rightarrow int$ con las mismas definiciones anteriores.\\
			
	\end{itemize}

	\item \textsl{combine\_resistances()}\\
	Este método forma parte del componente \textit{Combinator}, el cual es explicado en la sección \ref{sec:DescripFuncionamiento} del capitulo de Diseño.
		
	\begin{itemize}		
		\item \textit{Funcionalidad anterior: } Obtiene el producto cartesiano entre las posiciones de resistencia de los
			ARVs contenidos en el conjunto seleccionado.\\
			Luego, se aplican dos reglas sobre cada subconjunto del producto cartesiano, que actúan como filtro. Estas dos 
			reglas eliminan aquellos pares \textit{(pos, amin)} donde ambos pares tienen el mismo valor en \textit{pos}, pero 
			difieren en el valor de \textit{amin}. En el caso de que un subconjunto contenga más de un par con el mismo valor en 
			\textit{pos} y en \textit{amin}, se elimina uno de ellos para evitar repeticiones.\\	
			Por último, se arma un nuevo conjunto conteniendo aquellos subconjuntos del producto cartesiano que tengan la menor 
			cantidad de elementos.\\

			
\textbf{Pseudo-algoritmo}
\begin{lstlisting}[language=C++, basicstyle=\footnotesize\ttfamily]	
void combine_resistances(in: ARVs; out: ARVs_combined)
{
  make_cartesian_product(ARVs, ARVs_x);
  for each (subset in ARVs_x){
    apply_first_rule(subset);
    apply_second_rule(subset);
  }
  get_min(ARVs_x, ARVs_combined);  
} 
\end{lstlisting}
\vspace{0.5cm}
			
		\item \textit{Funcionalidad nueva: } Se realiza un pre procesamiento previo con el fin de eliminar información innecesaria. 					Debido a la nueva representación de la estructura de ARVs, se generan combinaciones manipulando los grupos que contiene cada 				ARV, y no a nivel de posiciones de resistencia como se realizaba anteriormente.\\			
			Luego, se filtran éstas combinaciones teniendo en cuenta el peso mínimo correspondiente a cada grupo.\\		 	 
			Por último, se expande cada aminoácido contenido en las combinaciones a sus correspondientes representaciones en 
			codones, obteniendo como resultado final todas las posibles combinaciones de los mismos.\\			
			
\textbf{Pseudo-algoritmo}
\begin{lstlisting}[language=C++, basicstyle=\footnotesize\ttfamily]	
void combine_resistances(in: ARVs; out: ARVs_combined)
{
  pre_processing(ARVs, sequence, ARVs_modified);
  calculate_power_set(ARVs_modified, R);
  power_set_minimized(R, Rm);   
  make_cartesian_product(Rm, Rx);  
  expand_to_codons(Rx, ARVs_combined);  
}  
\end{lstlisting}

	Para más detalle, ver los pasos del 1 al 5 de la sección \ref{pseudoalgoritmo}.
			
	\end{itemize}			

	\item \textsl{rank\_antivirals()}\\
	Este método forma parte del componente \textit{Ranker}, el cual es explicado en la sección \ref{sec:DescripFuncionamiento} del capitulo de Diseño.
	
		\begin{itemize}
			\item \textit{Funcionalidad anterior: } Dado un conjunto de ARVs, se arma un ranking conteniendo cada 
				ARV con su respectiva probabilidad. \\
				Por último se devuelve una lista de pares \textit{(ARV, probabilidad)}, donde \textit{probabilidad} 
				representa las chances que tiene el virus de escapar al ARV \textit{ARV}.\\

\textbf{Pseudo-algoritmo}
\begin{lstlisting}[language=C++, basicstyle=\footnotesize\ttfamily]	
void rank_antivirals(in: ARVs_combined; out: Ranking)
{
  for each (elem in ARVs_combined)
  {
    calculate_symmetric_probability(elem, prob_elem);
    Ranking.add([elem, prob_elem]);
  }
}  
\end{lstlisting}

Considerando a $add([elem, double]) \rightarrow void$ como la función de inserción de un elemento (en este caso un par) de listas.\\

			\item \textit{Funcionalidad nueva: } A partir de un conjunto de combinaciones representadas en codones, se 
				etiqueta cada una de ellas con un valor que simboliza la distancia entre ésta y la secuencia inicial.\\ 
				Por último, se confecciona un ranking que contiene sólo aquellas combinaciones cuyas distancias estén 
				dentro del rango determinado a partir de un porcentaje de tolerancia definido previamente.\\
				
\textbf{Pseudo-algoritmo}

\begin{lstlisting}[language=C++, basicstyle=\footnotesize\ttfamily]	
void rank_combinations(in: ARVs_combined; out: Ranking)
{
  for each (comb in ARVs_combined)
  {
    calculate_distance(comb, comb_dist);
    Ranking.add([comb, comb_dist]);
  }
}  
\end{lstlisting}				

Considerando a $add([elem, double]) \rightarrow void$ como la función de inserción de un elemento (en este caso un par) de listas.

Para más detalle, ver los pasos 6 y 7 de la sección \ref{pseudoalgoritmo}.					
\end{itemize}
			
\item \textsl{get\_mutants()}\\
Este método forma parte del componente \textit{Mutants}, el cual es explicado en la sección \ref{sec:DescripFuncionamiento} del capitulo de Diseño.

\begin{itemize}
	\item \textit{Funcionalidad anterior: } Calcula las mutaciones que se obtienen de una secuencia, a partir de la 
	aplicación de un conjunto de ARVs.\\ 
	Por último, se retorna una lista que contiene todas las mutaciones generadas anteriormente.\\
				
\textbf{Pseudo-algoritmo}
\begin{lstlisting}[language=C++, basicstyle=\footnotesize\ttfamily]	
void get_mutants(in: Ranking; out: Mutants)
{
  for each (comb in Ranking)
  {
    expand_to_nucleotids(comb, cc_comb);
    generate_mutants(cc_comb, cc_mutants);
    Mutants.add(cc_mutants);
  }
}  
\end{lstlisting}

Considerando a $add(elem) \rightarrow  void$ como la función de inserción de listas.\\
				
	\item \textit{Funcionalidad nueva: } Por cada combinación del conjunto de entrada, expresada en codones, se
	genera una nueva secuencia mutante, la cual consiste en reemplazar en la secuencia inicial, 
	cada triplete correspondiente a aquellas posiciones donde aplican los ARVs que componen a cada 
	combinación.\\
				
	\textbf{Pseudo-algoritmo}
				
	El pseudo-algoritmo para esta función corresponde al paso 8 de la sección \ref{pseudoalgoritmo}.
				 
	\end{itemize}				
			
\end{itemize}	
		
\pagebreak		
	
\section{Matriz de Probabilidades}\label{sec:MatrizProbabilidades}

Al momento de realizar la confección de la matriz se tuvieron en cuenta los siguientes modelos de evolución del ADN:
\begin{itemize}
	\item \textit{Modelo de Markov\cite{modMarkov}}: Las cadenas de Markov de tiempo continuo, tienen matrices de transición usuales\footnote{Matriz cuadrada con tantas filas y columnas como estados tiene el sistema.}, las cuales son, además, parametrizadas por tiempo \textit{t}. Específicamente, si $E_{1},...,E_{4}$ son estados, entonces la matriz de transición es:
		
		\begin{center}
		$P(t) = (P_{i,j}(t))$
		\end{center}

		donde cada entrada individual $P_{i,j}(t)$ en la matriz de transiciones hace referencia a la probabilidad que ese estado $E_{i}$ 			cambie a otro estado $E_{j}$ en un tiempo \textit{t}. Por ejemplo, si se quiere modelar el proceso de sustitución en las 					secuencias de ADN de forma continua en el tiempo:
		
		% Matriz del Modelo de Markov
		\[
		P(t)=
		\begin{pmatrix}
  		P_{A,A}(t) & P_{G,A}(t) & P_{C,A}(t) & P_{T,A}(t) \\ 
  		P_{A,G}(t) & P_{G,G}(t) & P_{C,G}(t) & P_{T,G}(t) \\
  		P_{A,C}(t) & P_{G,C}(t) & P_{C,C}(t) & P_{T,C}(t) \\
  		P_{A,T}(t) & P_{G,T}(t) & P_{C,T}(t) & P_{T,T}(t) 
 		\end{pmatrix}
 		\] 
		
		donde los bloques superior izquierdo  e inferior derecho de tamaño 2 x 2 corresponden a las probabilidades de transición y los 			bloques superior derecho e inferior izquierdo de tamaño 2 x 2 corresponden a las probabilidades de transversión.	
	
	\item \textit{Modelo Kimura\cite{Kimura80} (K80)}: El modelo K80 distingue entre transiciones ($A \leftrightarrow G$, por ejemplo, 			desde purina a purina, o $C \leftrightarrow T$, por ejemplo, desde pirimidina a pirimidina) y transversiones (desde purina a 				pirimidina o viceversa). En la descripción original del modelo de Kimura, se utilizaban $\alpha$ y $\beta$ para denotar las tasas 		de estos tipos de sustituciones. Denotar a la tasa de transversiones con \textit{1} y a la tasa de transición/transversión con 			\textit{k}, es ahora mas común. El modelo K80 asume que todas las bases son igualmente frecuentes ($\pi T = \pi C = \pi A = \pi G 		= 0.25$).

		% Matriz del Modelo Kimura
		\[
		Q =
		\begin{pmatrix}
  		* & k & 1 & 1 \\ 
  		k & * & 1 & 1 \\
  		1 & 1 & * & k \\
  		1 & 1 & k & * \\
 		\end{pmatrix}
 		\]
	
\end{itemize}

Estos modelos difieren en términos de los parámetros utilizados para describir la velocidad con la cual un nucleótido reemplaza a otro durante la evolución del ADN (Ver Sección \ref{tasa_mutaciones}).

 La información que contiene la matriz refleja el concepto de mutación asimétrica, es decir, que existen mutaciones mas probables que otras, como es el caso del fenómeno de hipermutación adenina-guanina.\cite{HipermutationAG}
 

\section{Dependencias externas} \label{dependenciasExternas}
	
Debido a que \aproba se relaciona con más de un proyecto desarrollados en \fudepan, se describen a continuación las librerías y proyectos más importantes que intervienen en la implementación del presente trabajo.
	
\subsection{MiLi}
Conjunto de librerías útiles generales de C++, únicamente de archivos ".h", que cumple con la filosofía de ``C++ es un lenguaje de 		dos caras", ya que encapsula complejidad del mismo ofreciendo simplicidad al usuario.
	
 MiLi\footnote{Para detalles técnicos ingresar a \url{http://mili.googlecode.com}} significa Minimalistic Libraries (Librerías Minimalistas) porque está enfocada en la simpleza de su incorporación en proyectos y facilidad de uso. Provee las herramientas básicas de programación general para los proyectos de \fudepan.
		
\subsection{Biopp}
Biblioteca C++ para Biología Molecular\footnote{Para detalles técnicos ingresar a \url{http://biopp.googlecode.com}}. Esta biblioteca es la que provee las estructuras de datos y métodos para manipular secuencias de codones, por lo que sirve de base para los proyectos que manipulan estructuras relacionadas con este tipo de secuencias.

\subsection{Fx-Parser}
FXP\footnote{Para detalles técnicos ingresar a \url{http://fx-parser.googlecode.com}} es un parser XML\footnote{Para mas información, ver sección \ref{xml}: ``Lenguaje XML (Extensible Markup Language)"} de alto nivel para C++. De hecho, FXP es un adaptador de datos que se sitúa por encima de un parser SAX (Simple API for XML Parsing), utilizado para parsear el archivo .xml que contiene la base de datos de ARVs. 


